Enhance guest memory accessor macros so that source operands can be

pointers to const or arrays.

Only build-tested on ia64, and untested for powerpc (which, however,
is almost identical to ia64, except for an apparent bug in the original
version of __copy_field_{from,to}_guest in that the field offset was
multiplied by the field size).

Signed-off-by: Jan Beulich <jbeulich@novell.com>

diff --git a/xen/arch/x86/mm.c b/xen/arch/x86/mm.c
index c53d28bbca0f63211e6bbce37b2ea5e544b48331..c86a895819f3ee02c39f164fa8f3d5de916cf506 100644 (file)
--- a/xen/arch/x86/mm.c
+++ b/xen/arch/x86/mm.c
@@ -2942,7 +2942,7 @@ long do_set_gdt(XEN_GUEST_HANDLE(ulong) frame_list, unsigned int entries)
     if ( entries > FIRST_RESERVED_GDT_ENTRY )
         return -EINVAL;
     
-    if ( copy_from_guest((unsigned long *)frames, frame_list, nr_pages) )
+    if ( copy_from_guest(frames, frame_list, nr_pages) )
         return -EFAULT;
 
     LOCK_BIGLOCK(current->domain);
@@ -3123,7 +3123,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE(void) arg)
         else if ( (d = rcu_lock_domain_by_id(fmap.domid)) == NULL )
             return -ESRCH;
 
-        rc = copy_from_guest(&d->arch.e820[0], fmap.map.buffer,
+        rc = copy_from_guest(d->arch.e820, fmap.map.buffer,
                              fmap.map.nr_entries) ? -EFAULT : 0;
         d->arch.nr_e820 = fmap.map.nr_entries;
 
@@ -3144,7 +3144,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE(void) arg)
             return -EFAULT;
 
         map.nr_entries = min(map.nr_entries, d->arch.nr_e820);
-        if ( copy_to_guest(map.buffer, &d->arch.e820[0], map.nr_entries) ||
+        if ( copy_to_guest(map.buffer, d->arch.e820, map.nr_entries) ||
              copy_to_guest(arg, &map, 1) )
             return -EFAULT;
 
@@ -3168,7 +3168,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE(void) arg)
         buffer = guest_handle_cast(memmap.buffer, e820entry_t);
 
         count = min((unsigned int)e820.nr_map, memmap.nr_entries);
-        if ( copy_to_guest(buffer, &e820.map[0], count) < 0 )
+        if ( copy_to_guest(buffer, e820.map, count) < 0 )
             return -EFAULT;
 
         memmap.nr_entries = count;
@@ -3181,7 +3181,7 @@ long arch_memory_op(int op, XEN_GUEST_HANDLE(void) arg)
 
     case XENMEM_machphys_mapping:
     {
-        struct xen_machphys_mapping mapping = {
+        static const struct xen_machphys_mapping mapping = {
             .v_start = MACH2PHYS_VIRT_START,
             .v_end   = MACH2PHYS_VIRT_END,
             .max_mfn = MACH2PHYS_NR_ENTRIES - 1

diff --git a/xen/arch/x86/traps.c b/xen/arch/x86/traps.c
index f97ea5e940687870854c40476094c359d984cc5d..c14847a6688b80a7d6f15f60e95383ed40832d7a 100644 (file)
--- a/xen/arch/x86/traps.c
+++ b/xen/arch/x86/traps.c
@@ -1140,7 +1140,7 @@ static inline int guest_io_okay(
          * read as 0xff (no access allowed).
          */
         TOGGLE_MODE();
-        switch ( __copy_from_guest_offset(&x.bytes[0], v->arch.iobmp,
+        switch ( __copy_from_guest_offset(x.bytes, v->arch.iobmp,
                                           port>>3, 2) )
         {
         default: x.bytes[0] = ~0;

diff --git a/xen/common/domctl.c b/xen/common/domctl.c
index a31ab05fe4185658a39fe0967debe3d1eb440685..4ecb3625b9a8ad4b098f0c6cbcf626a4a77c4908 100644 (file)
--- a/xen/common/domctl.c
+++ b/xen/common/domctl.c
@@ -43,7 +43,7 @@ void cpumask_to_xenctl_cpumap(
 
     bitmap_long_to_byte(bytemap, cpus_addr(*cpumask), NR_CPUS);
 
-    copy_to_guest(xenctl_cpumap->bitmap, &bytemap[0], copy_bytes);
+    copy_to_guest(xenctl_cpumap->bitmap, bytemap, copy_bytes);
 
     for ( i = copy_bytes; i < guest_bytes; i++ )
         copy_to_guest_offset(xenctl_cpumap->bitmap, i, &zero, 1);
@@ -63,7 +63,7 @@ void xenctl_cpumap_to_cpumask(
     if ( guest_handle_is_null(xenctl_cpumap->bitmap) )
         return;
 
-    copy_from_guest(&bytemap[0], xenctl_cpumap->bitmap, copy_bytes);
+    copy_from_guest(bytemap, xenctl_cpumap->bitmap, copy_bytes);
 
     bitmap_byte_to_long(cpus_addr(*cpumask), bytemap, NR_CPUS);
 }

diff --git a/xen/common/kernel.c b/xen/common/kernel.c
index a4dbc618e04695f1393251384abdb1bfa572dd14..f8e4f11a0ebecd0bf5e48677990f74450bf6c8f4 100644 (file)
--- a/xen/common/kernel.c
+++ b/xen/common/kernel.c
@@ -142,7 +142,7 @@ DO(xen_version)(int cmd, XEN_GUEST_HANDLE(void) arg)
     {
         xen_extraversion_t extraversion;
         safe_strcpy(extraversion, xen_extra_version());
-        if ( copy_to_guest(arg, (char *)extraversion, sizeof(extraversion)) )
+        if ( copy_to_guest(arg, extraversion, ARRAY_SIZE(extraversion)) )
             return -EFAULT;
         return 0;
     }
@@ -167,7 +167,7 @@ DO(xen_version)(int cmd, XEN_GUEST_HANDLE(void) arg)
         memset(info, 0, sizeof(info));
         arch_get_xen_caps(&info);
 
-        if ( copy_to_guest(arg, (char *)info, sizeof(info)) )
+        if ( copy_to_guest(arg, info, ARRAY_SIZE(info)) )
             return -EFAULT;
         return 0;
     }
@@ -187,7 +187,7 @@ DO(xen_version)(int cmd, XEN_GUEST_HANDLE(void) arg)
     {
         xen_changeset_info_t chgset;
         safe_strcpy(chgset, xen_changeset());
-        if ( copy_to_guest(arg, (char *)chgset, sizeof(chgset)) )
+        if ( copy_to_guest(arg, chgset, ARRAY_SIZE(chgset)) )
             return -EFAULT;
         return 0;
     }
@@ -229,8 +229,8 @@ DO(xen_version)(int cmd, XEN_GUEST_HANDLE(void) arg)
 
     case XENVER_guest_handle:
     {
-        if ( copy_to_guest(arg, (char *)current->domain->handle,
-                           sizeof(current->domain->handle)) )
+        if ( copy_to_guest(arg, current->domain->handle,
+                           ARRAY_SIZE(current->domain->handle)) )
             return -EFAULT;
         return 0;
     }    

diff --git a/xen/common/perfc.c b/xen/common/perfc.c
index 535a1c70922911a67d7b864e460f5f800ad7a35b..fe0958b30c28432b9fd82db123f64439c9889488 100644 (file)
--- a/xen/common/perfc.c
+++ b/xen/common/perfc.c
@@ -227,7 +227,7 @@ static int perfc_copy_info(XEN_GUEST_HANDLE_64(xen_sysctl_perfc_desc_t) desc,
     }
     BUG_ON(v != perfc_nbr_vals);
 
-    if ( copy_to_guest(desc, (xen_sysctl_perfc_desc_t *)perfc_d, NR_PERFCTRS) )
+    if ( copy_to_guest(desc, perfc_d, NR_PERFCTRS) )
         return -EFAULT;
     if ( copy_to_guest(val, perfc_vals, perfc_nbr_vals) )
         return -EFAULT;

diff --git a/xen/drivers/char/console.c b/xen/drivers/char/console.c
index 6d1d40beee1968e2dcd2aa1b730e98a2dcbdcc29..c3c982347f4ee9285fa9965de46abe5574e5530c 100644 (file)
--- a/xen/drivers/char/console.c
+++ b/xen/drivers/char/console.c
@@ -326,7 +326,7 @@ static long guest_console_write(XEN_GUEST_HANDLE(char) buffer, int count)
                 CONSOLEIO_write, count, buffer);
 
         kcount = min_t(int, count, sizeof(kbuf)-1);
-        if ( copy_from_guest((char *)kbuf, buffer, kcount) )
+        if ( copy_from_guest(kbuf, buffer, kcount) )
             return -EFAULT;
         kbuf[kcount] = '\0';
 

diff --git a/xen/include/asm-ia64/guest_access.h b/xen/include/asm-ia64/guest_access.h
index e0522d4157ece873a359e3411f931ccedd80166e..bed82e07340776090b9522df5cb7ab35e9b95914 100644 (file)
--- a/xen/include/asm-ia64/guest_access.h
+++ b/xen/include/asm-ia64/guest_access.h
@@ -76,28 +76,31 @@ extern int xencomm_handle_is_null(void *ptr);
     __copy_field_from_guest(ptr, hnd, field)
 
 #define __copy_to_guest_offset(hnd, idx, ptr, nr) ({                    \
-    const typeof(ptr) _d = (hnd).p;                                     \
-    const typeof(ptr) _s = (ptr);                                       \
+    const typeof(*(ptr)) *_s = (ptr);                                   \
+    void *_d = (hnd).p;                                                 \
+    ((void)((hnd).p == (ptr)));                                         \
     xencomm_copy_to_guest(_d, _s, sizeof(*_s)*(nr), sizeof(*_s)*(idx)); \
 })
 
 #define __copy_field_to_guest(hnd, ptr, field) ({                   \
-    const int _off = offsetof(typeof(*ptr), field);                 \
-    const typeof(ptr) _d = (hnd).p;                                 \
+    unsigned int _off = offsetof(typeof(*(hnd).p), field);          \
     const typeof(&(ptr)->field) _s = &(ptr)->field;                 \
+    void *_d = (hnd).p;                                             \
+    ((void)(&(hnd).p->field == &(ptr)->field));                     \
     xencomm_copy_to_guest(_d, _s, sizeof(*_s), _off);               \
 })
 
-#define __copy_from_guest_offset(ptr, hnd, idx, nr) ({                     \
-    const typeof(ptr) _s = (hnd).p;                                        \
-    const typeof(ptr) _d = (ptr);                                          \
-    xencomm_copy_from_guest(_d, _s, sizeof(*_s)*(nr), sizeof(*_s)*(idx));  \
+#define __copy_from_guest_offset(ptr, hnd, idx, nr) ({                    \
+    const typeof(*(ptr)) *_s = (hnd).p;                                   \
+    typeof(*(ptr)) *_d = (ptr);                                           \
+    xencomm_copy_from_guest(_d, _s, sizeof(*_d)*(nr), sizeof(*_d)*(idx)); \
 })
 
 #define __copy_field_from_guest(ptr, hnd, field) ({                 \
-    const int _off = offsetof(typeof(*ptr), field);                 \
-    const typeof(ptr) _s = (hnd).p;                                 \
-    const typeof(&(ptr)->field) _d = &(ptr)->field;                 \
+    unsigned int _off = offsetof(typeof(*(hnd).p), field);          \
+    const void *_s = (hnd).p;                                       \
+    typeof(&(ptr)->field) _d = &(ptr)->field;                       \
+    ((void)(&(hnd).p->field == &(ptr)->field));                     \
     xencomm_copy_from_guest(_d, _s, sizeof(*_d), _off);             \
 })
 

diff --git a/xen/include/asm-x86/guest_access.h b/xen/include/asm-x86/guest_access.h
index 0fc5bc98dc5b0ed85152e93516f4fb2b494f37dc..f95a4d16946eee6eb5e5a4fc3fcae4c62ae654ca 100644 (file)
--- a/xen/include/asm-x86/guest_access.h
+++ b/xen/include/asm-x86/guest_access.h
@@ -32,11 +32,12 @@
  * specifying an offset into the guest array.
  */
 #define copy_to_guest_offset(hnd, off, ptr, nr) ({      \
-    typeof(ptr) _x = (hnd).p;                           \
-    const typeof(ptr) _y = (ptr);                       \
+    const typeof(*(ptr)) *_s = (ptr);                   \
+    char (*_d)[sizeof(*_s)] = (void *)(hnd).p;          \
+    ((void)((hnd).p == (ptr)));                         \
     is_hvm_vcpu(current) ?                              \
-    copy_to_user_hvm(_x+(off), _y, sizeof(*_x)*(nr)) :  \
-    copy_to_user(_x+(off), _y, sizeof(*_x)*(nr));       \
+    copy_to_user_hvm(_d+(off), _s, sizeof(*_s)*(nr)) :  \
+    copy_to_user(_d+(off), _s, sizeof(*_s)*(nr));       \
 })
 
 /*
@@ -44,29 +45,30 @@
  * specifying an offset into the guest array.
  */
 #define copy_from_guest_offset(ptr, hnd, off, nr) ({    \
-    const typeof(ptr) _x = (hnd).p;                     \
-    typeof(ptr) _y = (ptr);                             \
+    const typeof(*(ptr)) *_s = (hnd).p;                 \
+    typeof(*(ptr)) *_d = (ptr);                         \
     is_hvm_vcpu(current) ?                              \
-    copy_from_user_hvm(_y, _x+(off), sizeof(*_x)*(nr)) :\
-    copy_from_user(_y, _x+(off), sizeof(*_x)*(nr));     \
+    copy_from_user_hvm(_d, _s+(off), sizeof(*_d)*(nr)) :\
+    copy_from_user(_d, _s+(off), sizeof(*_d)*(nr));     \
 })
 
 /* Copy sub-field of a structure to guest context via a guest handle. */
 #define copy_field_to_guest(hnd, ptr, field) ({         \
-    typeof(&(ptr)->field) _x = &(hnd).p->field;         \
-    const typeof(&(ptr)->field) _y = &(ptr)->field;     \
+    const typeof(&(ptr)->field) _s = &(ptr)->field;     \
+    void *_d = &(hnd).p->field;                         \
+    ((void)(&(hnd).p->field == &(ptr)->field));         \
     is_hvm_vcpu(current) ?                              \
-    copy_to_user_hvm(_x, _y, sizeof(*_x)) :             \
-    copy_to_user(_x, _y, sizeof(*_x));                  \
+    copy_to_user_hvm(_d, _s, sizeof(*_s)) :             \
+    copy_to_user(_d, _s, sizeof(*_s));                  \
 })
 
 /* Copy sub-field of a structure from guest context via a guest handle. */
 #define copy_field_from_guest(ptr, hnd, field) ({       \
-    const typeof(&(ptr)->field) _x = &(hnd).p->field;   \
-    typeof(&(ptr)->field) _y = &(ptr)->field;           \
+    const typeof(&(ptr)->field) _s = &(hnd).p->field;   \
+    typeof(&(ptr)->field) _d = &(ptr)->field;           \
     is_hvm_vcpu(current) ?                              \
-    copy_from_user_hvm(_y, _x, sizeof(*_x)) :           \
-    copy_from_user(_y, _x, sizeof(*_x));                \
+    copy_from_user_hvm(_d, _s, sizeof(*_d)) :           \
+    copy_from_user(_d, _s, sizeof(*_d));                \
 })
 
 /*
@@ -78,35 +80,37 @@
      array_access_ok((hnd).p, (nr), sizeof(*(hnd).p)))
 
 #define __copy_to_guest_offset(hnd, off, ptr, nr) ({    \
-    typeof(ptr) _x = (hnd).p;                           \
-    const typeof(ptr) _y = (ptr);                       \
+    const typeof(*(ptr)) *_s = (ptr);                   \
+    char (*_d)[sizeof(*_s)] = (void *)(hnd).p;          \
+    ((void)((hnd).p == (ptr)));                         \
     is_hvm_vcpu(current) ?                              \
-    copy_to_user_hvm(_x+(off), _y, sizeof(*_x)*(nr)) :  \
-    __copy_to_user(_x+(off), _y, sizeof(*_x)*(nr));     \
+    copy_to_user_hvm(_d+(off), _s, sizeof(*_s)*(nr)) :  \
+    __copy_to_user(_d+(off), _s, sizeof(*_s)*(nr));     \
 })
 
 #define __copy_from_guest_offset(ptr, hnd, off, nr) ({  \
-    const typeof(ptr) _x = (hnd).p;                     \
-    typeof(ptr) _y = (ptr);                             \
+    const typeof(*(ptr)) *_s = (hnd).p;                 \
+    typeof(*(ptr)) *_d = (ptr);                         \
     is_hvm_vcpu(current) ?                              \
-    copy_from_user_hvm(_y, _x+(off),sizeof(*_x)*(nr)) : \
-    __copy_from_user(_y, _x+(off), sizeof(*_x)*(nr));   \
+    copy_from_user_hvm(_d, _s+(off), sizeof(*_d)*(nr)) :\
+    __copy_from_user(_d, _s+(off), sizeof(*_d)*(nr));   \
 })
 
 #define __copy_field_to_guest(hnd, ptr, field) ({       \
-    typeof(&(ptr)->field) _x = &(hnd).p->field;         \
-    const typeof(&(ptr)->field) _y = &(ptr)->field;     \
+    const typeof(&(ptr)->field) _s = &(ptr)->field;     \
+    void *_d = &(hnd).p->field;                         \
+    ((void)(&(hnd).p->field == &(ptr)->field));         \
     is_hvm_vcpu(current) ?                              \
-    copy_to_user_hvm(_x, _y, sizeof(*_x)) :             \
-    __copy_to_user(_x, _y, sizeof(*_x));                \
+    copy_to_user_hvm(_d, _s, sizeof(*_s)) :             \
+    __copy_to_user(_d, _s, sizeof(*_s));                \
 })
 
 #define __copy_field_from_guest(ptr, hnd, field) ({     \
-    const typeof(&(ptr)->field) _x = &(hnd).p->field;   \
-    typeof(&(ptr)->field) _y = &(ptr)->field;           \
+    const typeof(&(ptr)->field) _s = &(hnd).p->field;   \
+    typeof(&(ptr)->field) _d = &(ptr)->field;           \
     is_hvm_vcpu(current) ?                              \
-    copy_from_user_hvm(_y, _x, sizeof(*_x)) :           \
-    __copy_from_user(_y, _x, sizeof(*_x));              \
+    copy_from_user_hvm(_d, _s, sizeof(*_d)) :           \
+    __copy_from_user(_d, _s, sizeof(*_d));              \
 })
 
 #endif /* __ASM_X86_GUEST_ACCESS_H__ */

diff --git a/xen/include/xen/compat.h b/xen/include/xen/compat.h
index ba992e526a227b4f4a05b5d77e617b30ea8d7fbd..bcd1d4ef6dcf6cc93b3f655cd880c04d5cbe659e 100644 (file)
--- a/xen/include/xen/compat.h
+++ b/xen/include/xen/compat.h
@@ -44,9 +44,10 @@
  * specifying an offset into the guest array.
  */
 #define copy_to_compat_offset(hnd, off, ptr, nr) ({                  \
-    const typeof(ptr) _x = (typeof(**(hnd)._) *)(full_ptr_t)(hnd).c; \
-    const typeof(*(ptr)) *const _y = (ptr);                          \
-    copy_to_user(_x + (off), _y, sizeof(*_x) * (nr));                \
+    const typeof(*(ptr)) *_s = (ptr);                                \
+    char (*_d)[sizeof(*_s)] = (void *)(full_ptr_t)(hnd).c;           \
+    ((void)((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c == (ptr)));     \
+    copy_to_user(_d + (off), _s, sizeof(*_s) * (nr));                \
 })
 
 /*
@@ -54,9 +55,9 @@
  * specifying an offset into the guest array.
  */
 #define copy_from_compat_offset(ptr, hnd, off, nr) ({                \
-    const typeof(ptr) _x = (typeof(**(hnd)._) *)(full_ptr_t)(hnd).c; \
-    const typeof(ptr) _y = (ptr);                                    \
-    copy_from_user(_y, _x + (off), sizeof(*_x) * (nr));              \
+    const typeof(*(ptr)) *_s = (typeof(**(hnd)._) *)(full_ptr_t)(hnd).c; \
+    typeof(*(ptr)) *_d = (ptr);                                      \
+    copy_from_user(_d, _s + (off), sizeof(*_d) * (nr));              \
 })
 
 #define copy_to_compat(hnd, ptr, nr)                                 \
@@ -67,16 +68,19 @@
 
 /* Copy sub-field of a structure to guest context via a compat handle. */
 #define copy_field_to_compat(hnd, ptr, field) ({                     \
-    typeof((ptr)->field) *const _x = &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field; \
-    const typeof((ptr)->field) *const _y = &(ptr)->field;            \
-    copy_to_user(_x, _y, sizeof(*_x));                               \
+    const typeof(&(ptr)->field) _s = &(ptr)->field;                  \
+    void *_d = &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field;   \
+    ((void)(&((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field ==    \
+            &(ptr)->field));                                         \
+    copy_to_user(_d, _s, sizeof(*_s));                               \
 })
 
 /* Copy sub-field of a structure from guest context via a compat handle. */
 #define copy_field_from_compat(ptr, hnd, field) ({                   \
-    typeof((ptr)->field) *const _x = &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field; \
-    typeof((ptr)->field) *const _y = &(ptr)->field;                  \
-    copy_from_user(_y, _x, sizeof(*_x));                             \
+    const typeof(&(ptr)->field) _s =                                 \
+        &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field;          \
+    typeof(&(ptr)->field) _d = &(ptr)->field;                        \
+    copy_from_user(_d, _s, sizeof(*_d));                             \
 })
 
 /*
@@ -84,18 +88,20 @@
  * Allows use of faster __copy_* functions.
  */
 #define compat_handle_okay(hnd, nr)                                  \
-    compat_array_access_ok((void *)(full_ptr_t)(hnd).c, (nr), sizeof(**(hnd)._))
+    compat_array_access_ok((void *)(full_ptr_t)(hnd).c, (nr),        \
+                           sizeof(**(hnd)._))
 
 #define __copy_to_compat_offset(hnd, off, ptr, nr) ({                \
-    const typeof(ptr) _x = (typeof(**(hnd)._) *)(full_ptr_t)(hnd).c; \
-    const typeof(*(ptr)) *const _y = (ptr);                          \
-    __copy_to_user(_x + (off), _y, sizeof(*_x) * (nr));              \
+    const typeof(*(ptr)) *_s = (ptr);                                \
+    char (*_d)[sizeof(*_s)] = (void *)(full_ptr_t)(hnd).c;           \
+    ((void)((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c == (ptr)));     \
+    __copy_to_user(_d + (off), _s, sizeof(*_s) * (nr));              \
 })
 
 #define __copy_from_compat_offset(ptr, hnd, off, nr) ({              \
-    const typeof(ptr) _x = (typeof(**(hnd)._) *)(full_ptr_t)(hnd).c; \
-    const typeof(ptr) _y = (ptr);                                    \
-    __copy_from_user(_y, _x + (off), sizeof(*_x) * (nr));            \
+    const typeof(*(ptr)) *_s = (typeof(**(hnd)._) *)(full_ptr_t)(hnd).c; \
+    typeof(*(ptr)) *_d = (ptr);                                      \
+    __copy_from_user(_d, _s + (off), sizeof(*_d) * (nr));            \
 })
 
 #define __copy_to_compat(hnd, ptr, nr)                               \
@@ -105,15 +111,18 @@
     __copy_from_compat_offset(ptr, hnd, 0, nr)
 
 #define __copy_field_to_compat(hnd, ptr, field) ({                   \
-    typeof((ptr)->field) *const _x = &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field; \
-    const typeof((ptr)->field) *const _y = &(ptr)->field;            \
-    __copy_to_user(_x, _y, sizeof(*_x));                             \
+    const typeof(&(ptr)->field) _s = &(ptr)->field;                  \
+    void *_d = &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field;   \
+    ((void)(&((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field ==    \
+            &(ptr)->field));                                         \
+    __copy_to_user(_d, _s, sizeof(*_s));                             \
 })
 
 #define __copy_field_from_compat(ptr, hnd, field) ({                 \
-    typeof((ptr)->field) *const _x = &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field; \
-    typeof((ptr)->field) *const _y = &(ptr)->field;                  \
-    __copy_from_user(_y, _x, sizeof(*_x));                           \
+    const typeof(&(ptr)->field) _s =                                 \
+        &((typeof(**(hnd)._) *)(full_ptr_t)(hnd).c)->field;          \
+    typeof(&(ptr)->field) _d = &(ptr)->field;                        \
+    __copy_from_user(_d, _s, sizeof(*_d));                           \
 })
 
 
@@ -169,7 +178,8 @@ void xlat_vcpu_runstate_info(struct vcpu_runstate_info *);
 int switch_compat(struct domain *);
 int switch_native(struct domain *);
 
-#define BITS_PER_GUEST_LONG(d) (!IS_COMPAT(d) ? BITS_PER_LONG : COMPAT_BITS_PER_LONG)
+#define BITS_PER_GUEST_LONG(d) \
+    (!IS_COMPAT(d) ? BITS_PER_LONG : COMPAT_BITS_PER_LONG)
 
 #else
 

diff --git a/xen/include/xen/xencomm.h b/xen/include/xen/xencomm.h
index e961cc66817ffb81e6b36628240705b1131da57a..95126ba67f617064daf2d3ab38dd059beec0d10b 100644 (file)
--- a/xen/include/xen/xencomm.h
+++ b/xen/include/xen/xencomm.h
@@ -47,17 +47,17 @@ static inline unsigned long xencomm_inline_addr(const void *handle)
     ((hnd).p == NULL || xencomm_handle_is_null((hnd).p))
 
 /* Offset the given guest handle into the array it refers to. */
-#define guest_handle_add_offset(hnd, nr) ({         \
-    const typeof((hnd).p) _ptr;                     \
-    xencomm_add_offset((void **)&((hnd).p), nr * sizeof(*_ptr));   \
+#define guest_handle_add_offset(hnd, nr) ({                             \
+    const typeof((hnd).p) _ptr;                                         \
+    xencomm_add_offset((void **)&((hnd).p), nr * sizeof(*_ptr));        \
 })
 
 /* Cast a guest handle to the specified type of handle. */
 #define guest_handle_cast(hnd, type) ({         \
     type *_x = (hnd).p;                         \
-    XEN_GUEST_HANDLE(type) _y; \
-    set_xen_guest_handle(_y, _x); \
-    _y; \
+    XEN_GUEST_HANDLE(type) _y;                  \
+    set_xen_guest_handle(_y, _x);               \
+    _y;                                         \
 })
 
 /* Since we run in real mode, we can safely access all addresses. That also
@@ -87,29 +87,32 @@ static inline unsigned long xencomm_inline_addr(const void *handle)
     __copy_field_from_guest(ptr, hnd, field)
 
 #define __copy_to_guest_offset(hnd, idx, ptr, nr) ({                \
-    const typeof(ptr) _x = (hnd).p;                                 \
-    const typeof(ptr) _y = (ptr);                                   \
-    xencomm_copy_to_guest(_x, _y, sizeof(*_x)*(nr), sizeof(*_x)*(idx)); \
+    const typeof(*(ptr)) *_s = (ptr);                               \
+    void *_d = (hnd).p;                                             \
+    ((void)((hnd).p == (ptr)));                                     \
+    xencomm_copy_to_guest(_d, _s, sizeof(*_s)*(nr), sizeof(*_s)*(idx)); \
 })
 
 #define __copy_field_to_guest(hnd, ptr, field) ({                   \
-    const int _off = offsetof(typeof(*ptr), field);                  \
-    const typeof(&(ptr)->field) _x = &(hnd).p->field;               \
-    const typeof(&(ptr)->field) _y = &(ptr)->field;                 \
-    xencomm_copy_to_guest(_x, _y, sizeof(*_x), sizeof(*_x)*(_off)); \
+    unsigned int _off = offsetof(typeof(*(hnd).p), field);          \
+    const typeof(&(ptr)->field) _s = &(ptr)->field;                 \
+    void *_d = (hnd).p;                                             \
+    ((void)(&(hnd).p->field == &(ptr)->field));                     \
+    xencomm_copy_to_guest(_d, _s, sizeof(*_s), _off);               \
 })
 
 #define __copy_from_guest_offset(ptr, hnd, idx, nr) ({              \
-    const typeof(ptr) _x = (hnd).p;                                 \
-    const typeof(ptr) _y = (ptr);                                   \
-    xencomm_copy_from_guest(_y, _x, sizeof(*_x)*(nr), sizeof(*_x)*(idx));  \
+    const typeof(*(ptr)) *_s = (hnd).p;                             \
+    typeof(*(ptr)) *_d = (ptr);                                     \
+    xencomm_copy_from_guest(_d, _s, sizeof(*_d)*(nr), sizeof(*_d)*(idx)); \
 })
 
 #define __copy_field_from_guest(ptr, hnd, field) ({                 \
-    const int _off = offsetof(typeof(*ptr), field);                 \
-    const typeof(&(ptr)->field) _x = &(hnd).p->field;               \
-    const typeof(&(ptr)->field) _y = &(ptr)->field;                 \
-    xencomm_copy_to_guest(_y, _x, sizeof(*_x), sizeof(*_x)*(_off)); \
+    unsigned int _off = offsetof(typeof(*(hnd).p), field);          \
+    const void *_s = (hnd).p;                                       \
+    typeof(&(ptr)->field) _d = &(ptr)->field;                       \
+    ((void)(&(hnd).p->field == &(ptr)->field));                     \
+    xencomm_copy_from_guest(_d, _s, sizeof(*_d), _off);             \
 })
 
 #endif /* __XENCOMM_H__ */